<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>面向对象OOP</title>
</head>
<body>
    <h2>类的继承、封装、多态</h2>
    <ul>
        <li>封装: 低耦合高内聚</li>
        <li>多态: 重载和重写</li>
        <li>继承: 子类继承父类方法和属性</li>
    </ul>
    <h2>----------------------------</h2>
    <h2>继承常用的方法</h2>
    <ul>
        <li>原型继承(原型链继承)</li>
        <li>call继承</li>
        <li>寄生组合继承</li>
        <li>ES6的Class Extend继承(extends和super)</li>
    </ul>
</body>
<script>
    /*
    * 面向对象:  类
    *   1. 解决问题 分类
    *   2. 一种编程思想
    *   面向对象是一种编程思想,与之对应的是面向过程;
    *   Promise Array Function Object
    *   new Promise  []  ()=>{}   {};
    *
    *   Promise ES6里新增的内置类, 我们可以通过new promise来创建一个实例, 用这个实例才管理异步操作
    *
    *   万物皆对象;
    *
    *   VUE/REACT/JQ 基于面向对象构建出来的.  new Vue
    *   平时都是通过new一个对象的实例来进行操作的.
    *
    *   通过研究一些实例的属性和方法, 来确定一些问题的分类 根据类的不同 而产生同类问题的解决方案 ===> 面向对象
    *
    *   我们自己创建的一些组件的封装(轮播图/选项卡/ajax ),方法的封装还有插件, 这些也都是基于面向对象开发的, 通过创造不同的实例, 来管理私有和共有的方法;
    *
    *
    *
    *
    *   后端面向对象和JS中的面向对象有所不同, JS中的类和实例是基于原型和原型链机制来处理的
    *
    *   后端面向对象: ===> {}
    *
    *
    * */

    //重写
    /*Array.prototype.map = function () {//重写

    };
    console.log = function () {//重写

    }*/

    //重载
    //  方法名相同 形参的个数或者数据类型不同 导致方法内部处理逻辑不同
//   public function sum(int a, b) {}
//    function sum(a) {}
    function sum(a, b) {
//        arguments


        switch (typeof a){
            case "string":
//                ....
                break;
            case "number":
//                ....
                break;
            case "object":
//                ....
                break;
            case "boolean":
//                ....
                break;
        }

        return a+b
    }

    sum(1,2); //number
    sum("1", "2") //string


//    node.js
//    request
//    /getData  高并发高请求

</script>
<!--<script src="./OOP/原型链继承.js"></script>-->
<!--<script src="./OOP/call继承.js"></script>-->
<!--<script src="./OOP/寄生组合继承.js"></script>-->
<script src="./OOP/ES6中的Class和继承.js"></script>
</html>